home *** CD-ROM | disk | FTP | other *** search
/ Scene 96 / Scene 96 International Edition (Zyklop Software) (Disc 2) (1997).iso / misc / coding / pump_src / tun3d.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-26  |  10.1 KB  |  305 lines
  1.  
  2. #include "pump.h"
  3.  
  4.  
  5. #define CLR_LEVELS 32
  6. byte tex[64*64];
  7.  
  8. #define NUMEDGES 10
  9.  
  10. typedef struct {
  11.     sint32 r;
  12.     sint32 l;
  13.     sint32 sl, tx, ty;
  14.     sint32 sx, sy;
  15. } TEdgePoint;
  16.  
  17. typedef struct {
  18.     sint32 cx, cy;
  19.     TEdgePoint p[NUMEDGES];
  20. } TTunSec;
  21.  
  22. #define MAXTUNZ     300000
  23. #define SECTIONZ     20000
  24. #define NUMSECTIONS (MAXTUNZ/SECTIONZ)
  25.  
  26. TTunSec Tunel[NUMSECTIONS];
  27. int     MaxTunSec = -1, NTunSec = -1, TunZ = SECTIONZ;
  28. bool    TunFull = FALSE;
  29.  
  30. #define LIGHT_LEVELS 31
  31.  
  32. PUBLIC void CalcLights(O3DM_PObject obj, dword ang) {
  33.     int i;
  34.     dword l;
  35.     O3DM_PVertex pv;
  36.     assert(obj != NULL);
  37.  
  38.     l = 0;
  39.     pv = obj->verts;
  40.     for (i = 0; i < obj->nVerts; i++, pv++, l += (5 << 10)) {
  41. //        pv->l = (16 << 16) + FPMult(15 << 16, Sin(ang + l));
  42.         pv->l = 0x1F0000 - (Pow2(pv->x >> 3) + Pow2(pv->y) >> 1) + FPMult(Sin(ang),0x3FF00);
  43.         if (pv->l > 0x1F0000)
  44.             pv->l = 0x1F0000;
  45.         else if (pv->l < 0)
  46.             pv->l = 0;
  47.     }
  48. }
  49.  
  50. void obj_test(O3DM_PObject obj, int lz, R3D_PAngles ang) {
  51.     R3D_TPosVector pos = { 000, 000, 10000 };
  52.     R3D_TRotMatrix rm;
  53.  
  54. //        memset(LLS_Screen[0], 0, LLS_Size);
  55.         pos[2] = lz;
  56.         R3D_Gen3DMatrix(&rm, ang);
  57.         O3DM_RotateObjVerts(obj, &rm);
  58.         O3DM_RotateObjNormals(obj, &rm);
  59.         O3DM_TranslateObj(obj, &pos);
  60.         O3DM_ProjectObject(obj);
  61.         O3DM_ParseVisibility(obj);
  62.         CalcLights(obj, ang[1]);
  63.         O3DM_Draw(obj);
  64. }
  65.  
  66. PRIVATE O3DM_PObject obj[8];
  67. PRIVATE byte *Pal = NULL, *Clr = NULL;
  68.  
  69. PUBLIC void InitTun(void) {
  70.     int i;
  71.     for (i = 0; i < SIZEARRAY(obj); i++) {
  72.         char buf[100];
  73.         sprintf(buf, "crdt%d.i3d", i);
  74.         obj[i] = O3DM_LoadObject(buf);
  75.         if (obj == NULL)
  76.             BASE_Abort("No se puede cargar el objeto %d", buf);
  77.     }
  78.     Pal = NEW(768);
  79.     Clr = NEW(32*256);
  80.     JCLIB_Load("tuntex1.pix", tex, sizeof(tex));
  81.     JCLIB_Load("tuntex1.pal", Pal, 768);
  82.     JCLIB_Load("tuntex1.clr", Clr, 32*256);
  83. }
  84.  
  85.  
  86. PRIVATE void DoIt(void) {
  87.     int nf;
  88.     int i;
  89.     int lz = 300000, nobj = 0;;
  90.     R3D_TAngles ang = {0, 0, 0};
  91.     bool fading = FALSE;
  92.  
  93.     MemSetD(LLS_Screen, 0x3F3F3F3F, LLS_Size);
  94.  
  95. //    POLY_MinX = 20;
  96. //    POLY_MaxX = 300;
  97. //    POLY_MinY = 20;
  98. //    POLY_MaxY = 180;
  99.     POLY_MinY = 20;
  100.     POLY_MaxY = 180;
  101.     LLS_UpdateMinY = POLY_MinY;
  102.     LLS_UpdateMaxY = POLY_MaxY;
  103.  
  104.     R3D_FocusX = 2*256;
  105.     R3D_FocusY = 2*256*5/6;
  106.  
  107.     while (LLK_SpacePressed == 0) {
  108.         int i, j, k;
  109.  
  110.         MemSetD(LLS_Screen, 0x3F3F3F3F, LLS_Size);
  111.  
  112.         {
  113.             sint32 z, pz;
  114.  
  115.             z = MAXTUNZ - 2*SECTIONZ + TunZ;
  116.             if (MaxTunSec < NUMSECTIONS)
  117.                 i = MaxTunSec;
  118.             else
  119.                 i = NTunSec;
  120.             for (j = 0; j < MaxTunSec; j++, i = (i+NUMSECTIONS-1)%NUMSECTIONS) {
  121.                 sint32 x, y;
  122.                 if (z < 256)
  123.                     pz = 256;
  124.                 else
  125.                     pz = z;
  126.                 for (k = 0; k < NUMEDGES; k++) {
  127.                     sint32 dl;
  128.                     x = Tunel[i].cx + FPMult(3*Tunel[i].p[k].r, Cos(k*65536/NUMEDGES+i*100));
  129. //                    x = Tunel[i].cx + (k-NUMEDGES/2)*0x4000;
  130.                     Tunel[i].p[k].sx = 160 + FPMultDiv(x, 256, pz);
  131.                     y = Tunel[i].cy + FPMult(Tunel[i].p[k].r, Sin(k*65536/NUMEDGES+i*100));
  132. //                    y = Tunel[i].cy + Tunel[i].p[k].r;
  133.                     Tunel[i].p[k].sy = 100 + FPMultDiv(y, 256, pz);
  134. //                    Tunel[i].p[k].sy = 50 + FPMultDiv(y, 256, pz);
  135.                     if (pz < MAXTUNZ/3)
  136.                         Tunel[i].p[k].sl = Tunel[i].p[k].l;
  137.                     else
  138.                         Tunel[i].p[k].sl = FPMultDiv(Tunel[i].p[k].l, MAXTUNZ - pz, MAXTUNZ - MAXTUNZ/3);
  139.                     if (nobj < SIZEARRAY(obj)) {
  140.                         dl = 0x1F0000 - FPMultDiv(0x1F0000,
  141.                                        Abs32(pz-lz),
  142.                                        SECTIONZ);
  143.                         if (Tunel[i].p[k].sl+dl > 0x1F0000)
  144.                             Tunel[i].p[k].sl = 0x1F0000;
  145.                         else if (dl >= 0)
  146.                            Tunel[i].p[k].sl += dl;
  147.                     }
  148.                 }
  149.                 z -= SECTIONZ;
  150.             }
  151.  
  152.             if (MaxTunSec < NUMSECTIONS)
  153.                 i = MaxTunSec;
  154.             else
  155.                 i = NTunSec;
  156.             for (j = 1; j < MaxTunSec; j++, i = (i+NUMSECTIONS-1)%NUMSECTIONS) {
  157.                 for (k = 0; k < NUMEDGES; k++) {
  158. //                for (k = 0; k < NUMEDGES-1; k++)
  159.                     sint32 kk, i1;
  160.                     kk = (k+1)%NUMEDGES;
  161.                     i1 = (i+NUMSECTIONS-1)%NUMSECTIONS;
  162.                     POLY_ScrapPoly[0].x = Tunel[i].p[k].sx;
  163.                     POLY_ScrapPoly[0].y = Tunel[i].p[k].sy;
  164.                     POLY_ScrapPoly[0].l = Tunel[i].p[k].sl;
  165.                     POLY_ScrapPoly[0].tx = 0;
  166.                     POLY_ScrapPoly[0].ty = 0;
  167.                     POLY_ScrapPoly[1].x = Tunel[i].p[kk].sx;
  168.                     POLY_ScrapPoly[1].y = Tunel[i].p[kk].sy;
  169.                     POLY_ScrapPoly[1].l = Tunel[i].p[kk].sl;
  170.                     POLY_ScrapPoly[1].tx = 64*POLY_TSMULT;
  171.                     POLY_ScrapPoly[1].ty = 0;
  172.                     POLY_ScrapPoly[2].x = Tunel[i1].p[kk].sx;
  173.                     POLY_ScrapPoly[2].y = Tunel[i1].p[kk].sy;
  174.                     POLY_ScrapPoly[2].l = Tunel[i1].p[kk].sl;
  175.                     POLY_ScrapPoly[1].tx = 0;
  176.                     POLY_ScrapPoly[1].ty = 64*POLY_TSMULT;
  177. //                    if (!fading) {
  178.                         POLY_ShadeTexDraw(POLY_ScrapPoly, 3, tex);
  179. /*
  180.                     } else {
  181.                         POLY_Line(POLY_ScrapPoly[0].x, POLY_ScrapPoly[0].y,
  182.                                   POLY_ScrapPoly[1].x, POLY_ScrapPoly[1].y,
  183.                                   23);
  184.                         POLY_Line(POLY_ScrapPoly[1].x, POLY_ScrapPoly[1].y,
  185.                                   POLY_ScrapPoly[2].x, POLY_ScrapPoly[2].y,
  186.                                   23);
  187.                         POLY_Line(POLY_ScrapPoly[2].x, POLY_ScrapPoly[2].y,
  188.                                   POLY_ScrapPoly[0].x, POLY_ScrapPoly[0].y,
  189.                                   23);
  190.                     }
  191. */
  192.                     POLY_ScrapPoly[0].x = Tunel[i].p[k].sx;
  193.                     POLY_ScrapPoly[0].y = Tunel[i].p[k].sy;
  194.                     POLY_ScrapPoly[0].l = Tunel[i].p[k].sl;
  195.                     POLY_ScrapPoly[0].tx = 0;
  196.                     POLY_ScrapPoly[0].ty = 0;
  197.                     POLY_ScrapPoly[1].x = Tunel[i1].p[kk].sx;
  198.                     POLY_ScrapPoly[1].y = Tunel[i1].p[kk].sy;
  199.                     POLY_ScrapPoly[1].l = Tunel[i1].p[kk].sl;
  200.                     POLY_ScrapPoly[1].tx = 0;
  201.                     POLY_ScrapPoly[1].ty = 64*POLY_TSMULT;
  202.                     POLY_ScrapPoly[2].x = Tunel[i1].p[k].sx;
  203.                     POLY_ScrapPoly[2].y = Tunel[i1].p[k].sy;
  204.                     POLY_ScrapPoly[2].l = Tunel[i1].p[k].sl;
  205.                     POLY_ScrapPoly[2].tx = 64*POLY_TSMULT;
  206.                     POLY_ScrapPoly[2].ty = 64*POLY_TSMULT;
  207. //                    if (!fading)
  208.                         POLY_ShadeTexDraw(POLY_ScrapPoly, 3, tex);
  209.                 }
  210.             }
  211.         }
  212.  
  213.         ang[1] = 0;
  214.         ang[0] = ang[2] = lz >> 3;
  215.         if (nobj < SIZEARRAY(obj))
  216.             obj_test(obj[nobj], lz, ang);
  217.  
  218. /*
  219.         for (i = 0; i < DVTInfo->numChannels; i++) {
  220.             if (DVTInfo->chansTrig[i]) {
  221.                 if (DVTInfo->chansData[i].ins == 9 || DVTInfo->chansData[i].ins == 9) {
  222. */
  223.         if (DVTInfo != NULL) {
  224.             if (!fading) {
  225.                 if (DVTInfo->semaphores[1] || DVTInfo->semaphores[2]) {
  226.                     byte buf[768];
  227.                     memset(buf, 63, 768);
  228.                     VBL_DumpPalette(buf, 0, 256);
  229.                     VBL_DestPal = GL_Pal;
  230.                     VBL_FadeMode =  VBL_FADEFAST;
  231.                     VBL_FadeStartColor = 0;
  232.                     VBL_FadeNColors = 256;
  233.                     VBL_FadePos = 1;
  234.                     VBL_FadeSpeed = 8;
  235.                 }
  236.                 DVTInfo->semaphores[1] = DVTInfo->semaphores[2] = 0;
  237.             }
  238.             DVTInfo->chansTrig[i] = 0;
  239.         }
  240.  
  241.         nf = VBL_VSync(1);
  242.         LLS_Update();
  243.  
  244.         while (nf-- > 0) {
  245.             lz -= 2*1024;
  246.             if (lz < 1024) {
  247.                 nobj++;
  248.                 lz = 300000;
  249.             }
  250.             TunZ -= 2*512;
  251.             if (TunZ < 0) {
  252.                 TunZ += SECTIONZ;
  253.                 if (MaxTunSec < NUMSECTIONS)
  254.                     MaxTunSec++;
  255.                 NTunSec = (NTunSec+1)%NUMSECTIONS;
  256.                 Tunel[NTunSec].cx = (rand() & 0x1FFF)-0x1000;
  257.                 Tunel[NTunSec].cy = (rand() & 0x1FFF)-0x1000;
  258.                 for (k = 0; k < NUMEDGES; k++) {
  259.                     Tunel[NTunSec].p[k].r = 0x3000 + (rand() % 0x1500);
  260.                     Tunel[NTunSec].p[k].l = ((rand() << 10) % (0x1F0000-0x100000)) + 0x40000;
  261.                 }
  262.             }
  263.         }
  264.         if (!fading && nobj > SIZEARRAY(obj)) {
  265.             VBL_DestPal = NULL;
  266.             VBL_DestRed = VBL_DestGreen = VBL_DestBlue = 0;
  267.             VBL_FadeMode =  VBL_FADEFAST;
  268.             VBL_FadeStartColor = 0;
  269.             VBL_FadeNColors = 256;
  270.             VBL_FadePos = 1;
  271.             VBL_FadeSpeed = 1;
  272.             fading = TRUE;
  273.         }
  274.  
  275.         if (fading && VBL_FadePos == 0)
  276.             break;
  277.     }
  278.     for (i = 0; i < SIZEARRAY(obj); i++)
  279.         O3DM_DeleteObject(obj[i]);
  280. }
  281.  
  282. PUBLIC void DoTun(void) {
  283.  
  284.     memset(LLS_Screen[0], 0, LLS_Size);
  285.     LLS_Update();
  286.  
  287.     memcpy(GL_Pal, Pal, 768);
  288.     memcpy(GL_ShadeTablePtr, Clr, 32*256);
  289.     VBL_DestPal = GL_Pal;
  290.     VBL_FadeStartColor = 0;
  291.     VBL_FadeNColors = 256;
  292.     VBL_FadeMode =  VBL_FADEFAST;
  293.     VBL_FadePos = 1;
  294.     VBL_FadeSpeed = 4;
  295.     memset(Pal, 63, 768);
  296.     VBL_DumpPalette(Pal, 0, 256);
  297.     DISPOSE(Pal);
  298.     DISPOSE(Clr);
  299.  
  300.     DoIt();
  301.     LLS_UpdateMinY = 0;
  302.     LLS_UpdateMaxY = LLS_SizeY;
  303. }
  304.  
  305.